/**
 * manager 启动一个定时器，不断检查是否有到期的任务，如果有就执行对应的处理器
 *
 */

package taskq

import (
	"context"
	"time"
	"strings"
	"night-school-api/pkg/redis"
)
// manager 启动一个定时器，不断检查是否有到期的任务，如果有就执行对应的处理器


type Manager struct {
	redisClient  *redis.Client
	handlers    map[string]TaskHandler
}

type TaskHandler func(ctx context.Context, taskID string) error

func NewManager(rc *redis.Client) *Manager {
	return &Manager{
		redisClient: rc,
		handlers:    make(map[string]TaskHandler),
	}
}

// 注册任务处理器
func (m *Manager) RegisterHandler(taskType string, handler TaskHandler) {
	m.handlers[taskType] = handler
}

// 启动任务消费协程
func (m *Manager) StartConsumer(ctx context.Context, queueKey string) {
	go func() {
		ticker := time.NewTicker(5 * time.Second)
		defer ticker.Stop()

		for {
			select {
			case <-ticker.C:
				m.processTasks(ctx, queueKey)
			case <-ctx.Done():
				return
			}
		}
	}()
}

func parseTaskType(taskID string) string {
	var t string
	colonIndex := strings.Index(taskID, ":")
	if colonIndex != -1 && colonIndex < len(taskID) {
		t = taskID[:colonIndex]
	} else {
		t = ""
	}
	return t
}

func (m *Manager) processTasks(ctx context.Context, queueKey string) {
	// 获取到期任务
	taskIDs, _ := m.redisClient.GetDueTasks(ctx, queueKey)
	
	for _, taskID := range taskIDs {
		// 分布式锁防止重复处理
		lockKey := "lock:" + taskID
		locked, _ := m.redisClient.Client.SetNX(ctx, lockKey, 1, 30*time.Second).Result()
		
		if locked {
			// 解析任务类型
			taskType := parseTaskType(taskID)
			
			if handler, exists := m.handlers[taskType]; exists {
				// 执行任务处理
				if err := handler(ctx, taskID); err == nil {
					// 处理成功删除任务
					m.redisClient.RemoveTask(ctx, queueKey, taskID)
				}
				// 释放锁
				m.redisClient.Client.Del(ctx, lockKey)
			}
		}
	}
}